import ast

from 程序核心代码.mvvm重构.基础定义.基础图形项.基础图形组件.节点基础图形项 import 带布局的节点基础图形项

from 程序核心代码.mvvm重构.基础定义.基础模型.ast节点模型基类 import ast节点基础模型
from 程序核心代码.mvvm重构.基础定义.节点管理器.自动节点注册表 import 注册节点模型, 节点模型匹配器, 注册节点图形项


#from 程序核心代码.ast节点.节点定义.基础定义.ast节点基础定义 import ast节点基础模型


@注册节点模型(ast.Assign)
class 普通赋值(ast节点基础模型):  # Assign

    def 节点数据解析(self):
        pass

    def __init__(self, ast节点, 所属节点模型管理器, 上级节点=None, 节点位置=None, 赋值目标节点=None, 值节点=None):
        super().__init__(ast节点, 所属节点模型管理器, "赋值节点", 节点位置=节点位置, 上级节点=上级节点)
        self.值节点 = 值节点
        self.赋值目标节点 = 赋值目标节点
        self.无图形项 = True
        self.初始化()

    def 初始化(self):

        if isinstance(self._ast节点.targets[0], ast.Tuple):
            print("进入自动解包")
            #起始接口.获取属性("节点名称") = "自动拆包"
            self.图形项 = 自动拆包节点图形项(self)
            # 赋值目标
            序号 = 0
            if isinstance(self._ast节点.value, (ast.List, ast.Tuple, ast.Set)):
                if len(self._ast节点.targets[0].elts)!= len(self._ast节点.value.elts):
                    print("自动拆包数量不匹配")
            elif isinstance(self._ast节点.value, ast.Dict):
                if len(self._ast节点.targets[0].elts)!= len(self._ast节点.value.keys):
                    print("自动拆包数量不匹配")

            for 赋值目标ast in self._ast节点.targets[0].elts:
                接口名称 = "数据输出 " + str(序号)
                if isinstance(赋值目标ast, ast.Starred):
                    接口名称 = 接口名称 + "扩展解包"
                    赋值目标ast = 赋值目标ast.value
                赋值目标节点 = 节点模型匹配器(赋值目标ast, self.所属节点模型管理器, 上级节点=self)
                起始接口 = self.添加接口到节点("数据流", "输出", 接口名称, 必须连接=True)
                结束接口 = 赋值目标节点.添加接口到节点("数据流", "输入", 必须连接=True)
                起始接口.接口创建连接线模型(结束接口, self)
                序号 += 1
            值节点 = 节点模型匹配器(self._ast节点.value, self.所属节点模型管理器, 上级节点=self)
            if 值节点:
                 起始接口 = 值节点.添加接口到节点("数据流", "输出", 必须连接=True)
                 结束接口 = self.添加接口到节点("数据流", "输入", 必须连接=True)
                 起始接口.接口创建连接线模型(结束接口, self)
        else:
            if not self.值节点:
                self.值处理()
            if not self.赋值目标节点:
                self.赋值目标处理()
            self.处理接口关系()

    def 赋值目标处理(self):
        self.赋值目标节点 = 节点模型匹配器(self._ast节点.targets[0], self.所属节点模型管理器, 上级节点=self)

    def 值处理(self):
        self.值节点 = 节点模型匹配器(self._ast节点.value, self.所属节点模型管理器, 上级节点=self)

    def 处理接口关系(self):
        if self.赋值目标节点 and self.值节点:
            起始接口 = self.值节点.添加接口到节点("数据流", "输出", 接口名称="数据输出", 必须连接=True)
            结束接口 = self.赋值目标节点.添加接口到节点("数据流", "输入", 接口名称="数据输入", 必须连接=True)
            起始接口.接口创建连接线模型(结束接口, self)

    def 多项赋值拆解(self):

        单项赋值列表 = []

        # 如果值部分是元组、列表、字典或集合的 AST 节点模型
        if isinstance(self._ast节点.value, (ast.Tuple, ast.List)):
            # 元组或列表解包
            for 目标, 值 in zip(self._ast节点.targets[0].elts, self._ast节点.value.elts):
                新赋值 = ast.Assign(targets=[目标], value=值)
                单项赋值列表.append(新赋值)
        elif isinstance(self._ast节点.value, ast.Dict):
            # 字典解包，默认解包的是键（keys）
            for 目标, 键 in zip(self._ast节点.targets[0].elts, self._ast节点.value.keys):
                新赋值 = ast.Assign(targets=[目标], value=键)
                单项赋值列表.append(新赋值)
        elif isinstance(self._ast节点.value, ast.Set):
            # 集合解包
            for 目标, 值 in zip(self._ast节点.targets[0].elts, self._ast节点.value.elts):
                新赋值 = ast.Assign(targets=[目标], value=值)
                单项赋值列表.append(新赋值)

        return 单项赋值列表

    def 节点处理删除关系(self, 要删除关系):
        # 删除关系!=删除 产生关系的节点

        if self.赋值目标节点 and self.值节点:
            孤立值 = 节点模型匹配器(ast.Expr(self.值节点._ast节点), self.所属节点模型管理器, 内部节点=self.值节点)
            孤立赋值目标 = 节点模型匹配器(ast.Expr(self.赋值目标节点._ast节点), self.所属节点模型管理器, 内部节点=self.赋值目标节点)

            结构树位置 = self.所属节点模型管理器._ast节点.index(self._ast节点)
            self.所属节点模型管理器._ast节点[结构树位置] = 孤立赋值目标._ast节点
            self.所属节点模型管理器._ast节点.insert(结构树位置, 孤立值._ast节点)

            # 起始接口.所属节点模型管理器.ast操作器.插入节点(起始接口.节点路径[:-1], 孤立值, 位置)
            # 起始接口.所属节点模型管理器.ast操作器.插入节点(起始接口.节点路径[:-1], 孤立赋值目标, 位置)
        # 起始接口.所属节点模型管理器.ast操作器.删除节点(起始接口.节点路径)
        return True

    def 删除节点(self, 要删除的节点=None):
        保留节点 = None
        if 要删除的节点 == self.赋值目标节点:
            保留节点 = self.值节点
        elif 要删除的节点 == self.值节点:
            保留节点 = self.赋值目标节点
        else:
            raise Exception("普通赋值节点 删除节点错误：", 要删除的节点)
        if 保留节点:
            # 起始接口.所属节点模型管理器.ast操作器.删除节点(起始接口.节点路径)
            节点 = ast.Expr(保留节点._ast节点)
            孤立保留节点 = 节点模型匹配器(ast.Expr(保留节点._ast节点), self.所属节点模型管理器, 内部节点=保留节点)
            结构树位置 = self.所属节点模型管理器._ast节点.index(self._ast节点)
            self.所属节点模型管理器._ast节点[结构树位置] = 孤立保留节点._ast节点
            # 起始接口.所属节点模型管理器._ast节点.insert(结构树位置, 孤立值._ast节点)
            要删除的节点.上级节点 = None
            要删除的节点.删除节点()
            super().删除节点()
        else:
            print(ast.dump(self._ast节点, annotate_fields=True, indent=4))
            raise Exception("删除节点错误：对应值节点为空 或者未解析")

@注册节点图形项(ast.Assign)
class 自动拆包节点图形项(带布局的节点基础图形项):

    def __init__(self, 节点定义,父容器节点图形项管理器, 父项=None):
        super().__init__(节点定义,父容器节点图形项管理器, 父项)


